/******************************************************************************
 * Spine Runtimes License Agreement
 * Last updated January 1, 2020. Replaces all prior versions.
 *
 * Copyright (c) 2013-2020, Esoteric Software LLC
 *
 * Integration of the Spine Runtimes into software or otherwise creating
 * derivative works of the Spine Runtimes is permitted under the terms and
 * conditions of Section 2 of the Spine Editor License Agreement:
 * http://esotericsoftware.com/spine-editor-license
 *
 * Otherwise, it is permitted to integrate the Spine Runtimes into software
 * or otherwise create derivative works of the Spine Runtimes (collectively,
 * "Products"), provided that each user of the Products must obtain their own
 * Spine Editor license and redistribution of the Products in any form must
 * include this license and copyright notice.
 *
 * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/

package com.esotericsoftware.spine;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
import com.badlogic.gdx.graphics.glutils.ShapeRenderer.ShapeType;
import com.badlogic.gdx.math.Vector2f;
import com.badlogic.gdx.utils.ArrayList;
import com.badlogic.gdx.utils.FloatArrayList;
import com.esotericsoftware.spine.attachments.Attachment;
import com.esotericsoftware.spine.attachments.BoundingBoxAttachment;
import com.esotericsoftware.spine.attachments.ClippingAttachment;
import com.esotericsoftware.spine.attachments.MeshAttachment;
import com.esotericsoftware.spine.attachments.PathAttachment;
import com.esotericsoftware.spine.attachments.PointAttachment;
import com.esotericsoftware.spine.attachments.RegionAttachment;
import com.xenoamess.cyan_potion.base.visual.Colors;
import org.joml.Vector4f;

public class SkeletonRendererDebug {
    static private final Vector4f boneLineColor =
            Colors.colorStringToColorVector4f(Colors.COLOR_STRING_RED);
    static private final Vector4f boneOriginColor =
            Colors.colorStringToColorVector4f(Colors.COLOR_STRING_GREEN);
    static private final Vector4f attachmentLineColor =
			Colors.colorStringToColorVector4f("0,0,1,0.5f");
    static private final Vector4f triangleLineColor =
			Colors.colorStringToColorVector4f("1,0.64f,0,0.5f");
    static private final Vector4f aabbColor =
			Colors.colorStringToColorVector4f("0, 1, 0, 0.5f");

    private final ShapeRenderer shapes;
    private boolean drawBones = true, drawRegionAttachments = true, drawBoundingBoxes = true, drawPoints = true;
    private boolean drawMeshHull = true, drawMeshTriangles = true, drawPaths = true, drawClipping = true;
    private final SkeletonBounds bounds = new SkeletonBounds();
    private final FloatArrayList vertices = new FloatArrayList(32);
    private float scale = 1;
    private float boneWidth = 2;
    private boolean premultipliedAlpha;
    private final Vector2f temp1 = new Vector2f(), temp2 = new Vector2f();

    public SkeletonRendererDebug() {
        shapes = new ShapeRenderer();
    }

    public SkeletonRendererDebug(ShapeRenderer shapes) {
        if (shapes == null)
            throw new IllegalArgumentException("shapes cannot be null.");
        this.shapes = shapes;
    }

    public void draw(Skeleton skeleton) {
        if (skeleton == null)
            throw new IllegalArgumentException("skeleton cannot be null.");

        Gdx.gl.glEnable(GL20.GL_BLEND);
        int srcFunc = premultipliedAlpha ? GL20.GL_ONE : GL20.GL_SRC_ALPHA;
        Gdx.gl.glBlendFunc(srcFunc, GL20.GL_ONE_MINUS_SRC_ALPHA);

        ShapeRenderer shapes = this.shapes;
        ArrayList<Bone> bones = skeleton.getBones();
        ArrayList<Slot> slots = skeleton.getSlots();

        shapes.begin(ShapeType.Filled);

        if (drawBones) {
            for (int i = 0, n = bones.size; i < n; i++) {
                Bone bone = bones.get(i);
                if (bone.parent == null || !bone.active)
                    continue;
                float length = bone.data.length, width = boneWidth;
                if (length == 0) {
                    length = 8;
                    width /= 2;
                    shapes.setColor(boneOriginColor);
                } else
                    shapes.setColor(boneLineColor);
                float x = length * bone.a + bone.worldX;
                float y = length * bone.c + bone.worldY;
                shapes.rectLine(bone.worldX, bone.worldY, x, y, width * scale);
            }
            shapes.x(skeleton.getX(), skeleton.getY(), 4 * scale);
        }

        if (drawPoints) {
            shapes.setColor(boneOriginColor);
            for (int i = 0, n = slots.size; i < n; i++) {
                Slot slot = slots.get(i);
                Attachment attachment = slot.attachment;
                if (!(attachment instanceof PointAttachment))
                    continue;
                PointAttachment point = (PointAttachment) attachment;
                point.computeWorldPosition(slot.getBone(), temp1);
                temp2.set(8, 0).rotate(point.computeWorldRotation(slot.getBone()));
                shapes.rectLine(temp1, temp2, boneWidth / 2 * scale);
            }
        }

        shapes.end();
        shapes.begin(ShapeType.Line);

        if (drawRegionAttachments) {
            shapes.setColor(attachmentLineColor);
            for (int i = 0, n = slots.size; i < n; i++) {
                Slot slot = slots.get(i);
                Attachment attachment = slot.attachment;
                if (attachment instanceof RegionAttachment) {
                    RegionAttachment region = (RegionAttachment) attachment;
                    float[] vertices = this.vertices.items;
                    region.computeWorldVertices(slot.getBone(), vertices, 0, 2);
                    shapes.line(vertices[0], vertices[1], vertices[2], vertices[3]);
                    shapes.line(vertices[2], vertices[3], vertices[4], vertices[5]);
                    shapes.line(vertices[4], vertices[5], vertices[6], vertices[7]);
                    shapes.line(vertices[6], vertices[7], vertices[0], vertices[1]);
                }
            }
        }

        if (drawMeshHull || drawMeshTriangles) {
            for (int i = 0, n = slots.size; i < n; i++) {
                Slot slot = slots.get(i);
                Attachment attachment = slot.attachment;
                if (!(attachment instanceof MeshAttachment))
                    continue;
                MeshAttachment mesh = (MeshAttachment) attachment;
                float[] vertices = this.vertices.setSize(mesh.getWorldVerticesLength());
                mesh.computeWorldVertices(slot, 0, mesh.getWorldVerticesLength(), vertices, 0, 2);
                short[] triangles = mesh.getTriangles();
                int hullLength = mesh.getHullLength();
                if (drawMeshTriangles) {
                    shapes.setColor(triangleLineColor);
                    for (int ii = 0, nn = triangles.length; ii < nn; ii += 3) {
                        int v1 = triangles[ii] * 2, v2 = triangles[ii + 1] * 2, v3 = triangles[ii + 2] * 2;
                        shapes.triangle(vertices[v1], vertices[v1 + 1], //
                                vertices[v2], vertices[v2 + 1], //
                                vertices[v3], vertices[v3 + 1] //
                        );
                    }
                }
                if (drawMeshHull && hullLength > 0) {
                    shapes.setColor(attachmentLineColor);
                    float lastX = vertices[hullLength - 2], lastY = vertices[hullLength - 1];
                    for (int ii = 0, nn = hullLength; ii < nn; ii += 2) {
                        float x = vertices[ii], y = vertices[ii + 1];
                        shapes.line(x, y, lastX, lastY);
                        lastX = x;
                        lastY = y;
                    }
                }
            }
        }

        if (drawBoundingBoxes) {
            SkeletonBounds bounds = this.bounds;
            bounds.update(skeleton, true);
            shapes.setColor(aabbColor);
            shapes.rect(bounds.getMinX(), bounds.getMinY(), bounds.getWidth(), bounds.getHeight());
            ArrayList<FloatArrayList> polygons = bounds.getPolygons();
            ArrayList<BoundingBoxAttachment> boxes = bounds.getBoundingBoxes();
            for (int i = 0, n = polygons.size; i < n; i++) {
                FloatArrayList polygon = polygons.get(i);
                shapes.setColor(boxes.get(i).getColor());
                shapes.polygon(polygon.items, 0, polygon.size);
            }
        }

        if (drawClipping) {
            for (int i = 0, n = slots.size; i < n; i++) {
                Slot slot = slots.get(i);
                Attachment attachment = slot.attachment;
                if (!(attachment instanceof ClippingAttachment))
                    continue;
                ClippingAttachment clip = (ClippingAttachment) attachment;
                int nn = clip.getWorldVerticesLength();
                float[] vertices = this.vertices.setSize(nn);
                clip.computeWorldVertices(slot, 0, nn, vertices, 0, 2);
                shapes.setColor(clip.getColor());
                for (int ii = 2; ii < nn; ii += 2)
                    shapes.line(vertices[ii - 2], vertices[ii - 1], vertices[ii], vertices[ii + 1]);
                shapes.line(vertices[0], vertices[1], vertices[nn - 2], vertices[nn - 1]);
            }
        }

        if (drawPaths) {
            for (int i = 0, n = slots.size; i < n; i++) {
                Slot slot = slots.get(i);
                Attachment attachment = slot.attachment;
                if (!(attachment instanceof PathAttachment))
                    continue;
                PathAttachment path = (PathAttachment) attachment;
                int nn = path.getWorldVerticesLength();
                float[] vertices = this.vertices.setSize(nn);
                path.computeWorldVertices(slot, 0, nn, vertices, 0, 2);
                Color color = path.getColor();
                float x1 = vertices[2], y1 = vertices[3], x2 = 0, y2 = 0;
                if (path.getClosed()) {
                    shapes.setColor(color);
                    float cx1 = vertices[0], cy1 = vertices[1], cx2 = vertices[nn - 2], cy2 = vertices[nn - 1];
                    x2 = vertices[nn - 4];
                    y2 = vertices[nn - 3];
                    shapes.curve(x1, y1, cx1, cy1, cx2, cy2, x2, y2, 32);
                    shapes.setColor(Color.LIGHT_GRAY);
                    shapes.line(x1, y1, cx1, cy1);
                    shapes.line(x2, y2, cx2, cy2);
                }
                nn -= 4;
                for (int ii = 4; ii < nn; ii += 6) {
                    float cx1 = vertices[ii], cy1 = vertices[ii + 1], cx2 = vertices[ii + 2], cy2 = vertices[ii + 3];
                    x2 = vertices[ii + 4];
                    y2 = vertices[ii + 5];
                    shapes.setColor(color);
                    shapes.curve(x1, y1, cx1, cy1, cx2, cy2, x2, y2, 32);
                    shapes.setColor(Color.LIGHT_GRAY);
                    shapes.line(x1, y1, cx1, cy1);
                    shapes.line(x2, y2, cx2, cy2);
                    x1 = x2;
                    y1 = y2;
                }
            }
        }

        shapes.end();
        shapes.begin(ShapeType.Filled);

        if (drawBones) {
            shapes.setColor(boneOriginColor);
            for (int i = 0, n = bones.size; i < n; i++) {
                Bone bone = bones.get(i);
                if (!bone.active)
                    continue;
                shapes.circle(bone.worldX, bone.worldY, 3 * scale, 8);
            }
        }

        if (drawPoints) {
            shapes.setColor(boneOriginColor);
            for (int i = 0, n = slots.size; i < n; i++) {
                Slot slot = slots.get(i);
                Attachment attachment = slot.attachment;
                if (!(attachment instanceof PointAttachment))
                    continue;
                PointAttachment point = (PointAttachment) attachment;
                point.computeWorldPosition(slot.getBone(), temp1);
                shapes.circle(temp1.x, temp1.y, 3 * scale, 8);
            }
        }

        shapes.end();

    }

    public ShapeRenderer getShapeRenderer() {
        return shapes;
    }

    public void setBones(boolean bones) {
        this.drawBones = bones;
    }

    public void setScale(float scale) {
        this.scale = scale;
    }

    public void setRegionAttachments(boolean regionAttachments) {
        this.drawRegionAttachments = regionAttachments;
    }

    public void setBoundingBoxes(boolean boundingBoxes) {
        this.drawBoundingBoxes = boundingBoxes;
    }

    public void setMeshHull(boolean meshHull) {
        this.drawMeshHull = meshHull;
    }

    public void setMeshTriangles(boolean meshTriangles) {
        this.drawMeshTriangles = meshTriangles;
    }

    public void setPaths(boolean paths) {
        this.drawPaths = paths;
    }

    public void setPoints(boolean points) {
        this.drawPoints = points;
    }

    public void setClipping(boolean clipping) {
        this.drawClipping = clipping;
    }

    public void setPremultipliedAlpha(boolean premultipliedAlpha) {
        this.premultipliedAlpha = premultipliedAlpha;
    }
}
